export default {
    props: {
        skuCompareKeyField: {
            type: String,
            default: 'attributes'
        },
        attrCompareKeyField: {
            type: String,
            default: 'title'
        },
        attrCompareValueField: {
            type: String,
            default: 'key'
        }
    },
    // 定义每个组件都可能需要用到的外部样式以及类名
    data() {
        return {
            isSkuActivity: true, // 是否完成活动 sku 选择
            isSkuDefault: false, // 是否完成默认sku选择
            isSkuInit: false, // 是否完成 sku 初始化
            isSkuClickComplete: false, // sku 是否选择完成
            currentSelectedSet: [] // 当前选中合集
        };
    },
    methods: {
        /**
         * sku 选择
         */
        /**
         * @description 选择默认sku
         * @author @小小只^v^ <littlezov@qq.com>
         * @param {Array} specMeta 属性列表
         * @param {Array} skuMeta sku列表数据
         * @return 不会有返回值，因为此函数在immer的produce作用域里执行，所以最终会处理为一个不可变的属性列表数据
         */
        checkDefaultSku() {
            const { specMeta, skuMeta } = this;
            skuMeta.forEach((sku, index) => {
                if (sku.default && sku.image) this.defaultSkuImage = sku.image; //  默认sku 图片
                // 选中 活动sku
                if (!this.isSkuClickComplete && this.isSkuActivity && sku.activity_price > 0 && sku.stock > 0) {
                    console.time('活动sku选中耗时', '活动sku未选中耗时');
                    this.initSku(specMeta, sku);
                    if (this.currentSelectedSet.length == 0) {
                        console.timeEnd('活动sku未选中耗时');
                        console.log('this.selectedSku', this.selectedSku);

                        return false;
                    } else {
                        console.timeEnd('活动sku选中耗时');
                        console.log('this.selectedSku', this.selectedSku);

                        return false;
                    }
                }
                // 无活动 选择默认sku
                if (!this.isSkuClickComplete && !this.isSkuActivity && this.isSkuDefault && sku.default && sku.stock > 0) {
                    console.log('默认sku选中耗时');
                    console.time('默认sku选中耗时', '默认sku未选中耗时');
                    this.initSku(specMeta, sku);
                    if (this.currentSelectedSet.length == 0) {
                        console.timeEnd('默认sku未选中耗时');
                        console.log('this.selectedSku', this.selectedSku);
                        return false;
                    } else {
                        console.timeEnd('默认sku选中耗时');
                        console.log('this.selectedSku', this.selectedSku);
                        return false;
                    }
                }
                //　默认sku无库存 and 活动
                if (!this.isSkuClickComplete && !this.isSkuActivity && !this.isSkuDefault && sku.stock > 0) {
                    console.time('随机sku选中耗时', '随机sku未选中耗时');
                    this.initSku(specMeta, sku);
                    if (this.currentSelectedSet.length == 0) {
                        console.timeEnd('随机sku未选中耗时');
                        console.log('this.selectedSku', this.selectedSku);
                        return false;
                    } else {
                        console.timeEnd('随机sku选中耗时');
                        console.log('this.selectedSku', this.selectedSku);
                        return false;
                    }
                }
            });
            if (!this.isSkuClickComplete && this.isSkuActivity) {
                this.isSkuActivity = false;
                this.isSkuDefault = true;
                this.checkDefaultSku(specMeta, skuMeta);
            }
            if (!this.isSkuClickComplete && !this.isSkuActivity && this.isSkuDefault) {
                this.isSkuDefault = false;
                this.checkDefaultSku(specMeta, skuMeta);
            }
        },
        /**
         * @description sku 初始化
         * @author @小小只^v^ <littlezov@qq.com>
         * @return 不会有返回值，因为此函数在immer的produce作用域里执行，所以最终会处理为一个不可变的属性列表数据
         */
        initSku(specMeta, sku) {
            // const { specMeta, skuMeta } = this;
            if (specMeta && sku) {
                // const skuAttr = skuMeta.map(item => item[this.skuCompareKeyField]).flat(2)
                const skuAttrValues = sku[this.skuCompareKeyField].map((item) => item.value);
                specMeta.forEach((item, rowIndex) => {
                    item.value.forEach((specValue, colIndex) => {
                        if (this.$lz.inArray(specValue[this.attrCompareValueField], skuAttrValues)) {
                            this.handleCheckSku(rowIndex, colIndex);
                        } else false; //终止当前流程
                    });
                    if (this.currentSelectedSet.length == 0) {
                        return false;
                    }
                });
            } else {
                console.info('找不到规格或属性');
            }
        },
        /**
         * @description sku选择
         * @author @小小只^v^ <littlezov@qq.com>
         * @param {Number} rowIndex 当前选中行
         * @param {Number} colIndex 当前选中列
         * @return 不会有返回值，因为此函数在immer的produce作用域里执行，所以最终会处理为一个不可变的属性列表数据
         */
        handleCheckSku(rowIndex, colIndex) {
            console.time('sku 选择耗时' + rowIndex + '-' + colIndex);
            const { specMeta } = this;
            const specItem = specMeta[rowIndex];
            specItem.value.forEach((specValue, index) => {
                if (index === colIndex) {
                    if (specValue.checked) {
                        specValue.checked = false;
                        specItem.current = null;
                    } else {
                        specValue.checked = true;
                        specItem.current = specValue[this.attrCompareValueField];
                    }
                } else {
                    specValue.checked = false;
                }
            });
            // console.timeLog("sku 选择耗时" + rowIndex + '-' + colIndex);
            console.timeEnd('sku 选择耗时' + rowIndex + '-' + colIndex);
            this.setAttrOptionStatus(specMeta, this.skuMeta);
        },
        /**
         * @description 验证是否选择完成
         * @author @小小只^v^ <littlezov@qq.com>
         * @param {Array} selectedSet sku选择合集
         * @return 不会有返回值，因为此函数在immer的produce作用域里执行，所以最终会处理为一个不可变的属性列表数据
         */
        clickSkuComplete(selectedSet) {
            const skuMeta = this.skuMeta;
            skuMeta &&
                skuMeta.some((sku) => {
                    const key = sku[this.skuCompareKeyField];
                    const checked = new Set(selectedSet);
                    //  取出交集
                    const intersect = key.filter((x) => checked.has(x.value));
                    console.log('key :>> ', key);
                    console.log('intersect :>> ', intersect);
                    console.log('checked :>> ', checked);

                    // 验证是否选择完成
                    if (intersect.length === key.length) {
                        this.isSkuClickComplete = true;
                        sku.sum = sku.min > 0 ? sku.min : 1;
                        this.selectedSku = sku;
                        console.log('sku :>> ', sku);
                        this.$emit('selectedSku', sku);
                        return true;
                    }
                    this.selectedSku = {};
                    this.$emit('selectedSku', {});
                    this.isSkuClickComplete = false;
                });
        },
        /**
         * @description 设置规格选项的置灰状态
         * @author @小小只^v^ <littlezov@qq.com>
         * @param {Array} specMeta 属性列表
         * @param {Array} skuMeta sku列表数据
         * @return 不会有返回值，因为此函数在immer的produce作用域里执行，所以最终会处理为一个不可变的属性列表数据
         */
        setAttrOptionStatus(specMeta, skuMeta) {
            // 1.获取已选规格集合{A}
            const selectedSet = specMeta.reduce((arr, item) => {
                item.current && (arr[item[this.attrCompareKeyField]] = item.current);
                return arr;
            }, {});
            // 2.遍历所有待选规格
            specMeta &&
                specMeta.forEach((specItem) => {
                    specItem.value.forEach((specValue) => {
                        if (specValue.checked) {
                            return false;
                        }
                        // 3.待选项{x}与已选项{A}组成新的集合B = {A,x}
                        const nextSelectSet = {
                            ...selectedSet,
                            [specItem[this.attrCompareKeyField]]: specValue[this.attrCompareValueField]
                        };
                        const keys = Object.keys(nextSelectSet);
                        /*
            4.遍历sku列表，
            看能否找到（1）选项匹配 且(2)有货的sku
            (1)选项匹配：找到sku对应的规格集合C,判断B与C是否具有包含关系 B <= C ?
            （2）判断库存
            查找结果为否，则此按钮需要置灰，反之亦然。
            */
                        specValue.disabled =
                            skuMeta &&
                            skuMeta.findIndex((sku) => {
                                return keys.every(
                                    (attrKey) =>
                                        sku.stock > 0 &&
                                        sku[this.skuCompareKeyField].findIndex((specValue) => {
                                            if (specValue === nextSelectSet[attrKey]) {
                                                return specValue;
                                            }
                                        }) > -1
                                );
                            }) === -1;
                    });
                });
            this.currentSelectedSet = Object.values(selectedSet);
            this.clickSkuComplete(Object.values(selectedSet));
            // this.isSkuInit = true;
        },
        /**
         * sku 选择 end
         */
        // 初始化测试数据
        initData({ pk = 1, size, page, total = 10 }, item) {
            let list = [];
            let start = 0,
                end = 0;
            console.log('size && page', size && page);
            if (size && page) {
                start = Number(pk) + (Number(page) - 1) * Number(size);
                end = Number(start) + Number(size);
                console.log('start end', start, end);
            } else {
                start = Number(pk);
                end = Number(total);
            }
            if (end >= total) end = total;
            console.log(`测试数据构建起始值：页数：${page}<====>条数：${size}<====>开始值：${start}<====>结束值：${end}<====>总数：${total}`);
            for (start; start < end; start++) {
                const data = item.replace(/PK/g, start);
                list = this.$lz.union(list, [JSON.parse(data)]);
            }
            return new Promise((resolve, reject) => {
                if (list.length) {
                    resolve({
                        code: 200,
                        message: 'ok',
                        data: list,
                        count: list.length,
                        more: end != total
                    });
                } else {
                    reject({
                        code: -1,
                        message: 'not data'
                    });
                }
            });
        }
    }
};
